/******************************************
 * Métodos Numéricos - TP1 "Mandelzoom"
 *
 * bigfloatr.cpp
 * Implementación dummy de BigFloat que envuelve un long double
 *
 ******************************************/
 
#include "bigfloat.h"

#include <cstdlib>

using namespace std;

    /**
     * Constructor default. Inicializa su valor en 0.
     */
    BigFloat::BigFloat(int precision) {
        this->val = 0;
    }

    /**
     * Constructor por copia.
     */
    BigFloat::BigFloat(const BigFloat& otro) {
        this->val = otro.val;
    }

    /**
     * Operador de asignación que realiza una copia.
     */
    BigFloat& BigFloat::operator=(const BigFloat& otro) {
        this->val = otro.val;
        return *this;
    }

    BigFloat::~BigFloat() {}

    /**
     * Construye un BigFloat a partir de un array de char.
     */
    BigFloat::BigFloat(int precision, char* c) {
        this->val = strtold(c, 0);
    }

    /**
     * Construye un BigFloat a partir de un double.
     */
    BigFloat::BigFloat(int precision, double d) {
	    this->val = d;
    }

    /**
     * Construye un BigFloat a partir de sus campos:
     * precision, signo, mantisa y exponente.
     * El array que contiene la mantisa se copia.
     */
    BigFloat::BigFloat(int precision, bool signo, short mantisa[], int exponente) {
        //TODO implementar
	    cerr << "BigFloat::BigFloat(int, bool, short[], int) no implementado" << endl;
    }

    /**
     * Suma a este BigFloat otro. Retorna this.
     */
    BigFloat& BigFloat::sumar(const BigFloat& otro) {
        this->val += otro.val;
	    return *this;
    }

    /**
     * Resta de este BigFloat otro. Retorna this.
     */
    BigFloat& BigFloat::restar(const BigFloat& otro) {
        this->val -= otro.val;
	    return *this;
    }

	/**
     * Multiplica este BigFloat por otro. Retorna this.
     */
    BigFloat& BigFloat::multiplicar(const BigFloat& otro) {
        this->val *= otro.val;
	    return *this;
    }

    /**
     * Multiplica este BigFloat por sí mismo. Retorna this.
     */
    BigFloat& BigFloat::cuadrar() {
        // TODO se puede optimizar
        return this->multiplicar(*this);
    }

	/**
	 * Indica si el BigFloat es mayor que cero.
	 */
	bool BigFloat::positivo() const {
	    return this->val > 0;
	}

	/**
	 * Indica si este BigFloat es mayor que el pasado por parámetro.
	 */
	bool BigFloat::mayor(const BigFloat& que) const {
	    return this->val > que.val;
	}

	/**
	 * Calcula la división entre dos BigFloat's, sujeto a las siguientes
	 * condiciones:
	 *      - ambos parámetros son positivos;
	 *      - num < 10;
	 *      - el resultado estará entre 40 y 4000. (luego div < 1/4);
	 */
	int BigFloat::razon(const BigFloat& num, const BigFloat& div) {
	    return num.val / div.val;
	}

	/**
	 * Muestra el BigFloat en un stream de salida.
	 */
	ostream& BigFloat::mostrar(ostream& out) const {
	    return out << this->val;
	}

/**
 * Sobrecarga de operator<< que muestra el BigFloat en un stream.
 */
ostream& operator<<(ostream& out, const BigFloat& n) {
    return n.mostrar(out);
}
